var _n14;
var cc__extends = __extends;
var cc__createBinding = __createBinding;
var cc__setModuleDefault = __setModuleDefault;
var cc__importStar = __importStar;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var def_IClassNamespace;
var $1$zqcc_OverallSystem = require("zqcc_OverallSystem");
var u = cc__importStar($1$zqcc_OverallSystem);
var $1$TimePlugIn = require("TimePlugIn");
var p = cc__importDefault($1$TimePlugIn);
(function (t) {
  var e = function () {
    function t() { }
    t.prototype._Initialize = function () {
      console.log("---------", this._className, "------创建完毕");
    };
    t.prototype.clear = function () {
      console.log("---------", this._className, "------清除完毕");
    };
    return t;
  }();
  var o = function (t) {
    function e() {
      // 调用t函数，如果t为null则使用this
      const e = null !== t && t.apply(this, arguments) || this;

      // 为e添加属性
      e.enableTouchEventKey = "ipha-touch-item-enable-event-key";
      e.disableTouchEventKey = "ipha-touch-item-disable-event-key";

      // 返回e
      return e;
    }
    cc__extends(e, t);
    return e;
  }(cc.Component);
  t.ItemTouch = o;
  var n = function (t) {
    function e(e, o) {
      // 调用t函数，如果失败则使用this
      const n = t.call(this) || this;

      // 设置n的初始属性
      n._className = "Ipha_ClickCnt";
      n.delay = Math.max(5, o || 0); // 根据o设定delay，确保不小于0
      n.maxCount = Math.max(5, e || 1); // 根据e设定maxCount，确保不小于1
      n.date = 0;
      n.count = 0;

      // 初始化n
      n._Initialize();

      // 返回n
      return n;
    }
    cc__extends(e, t);
    e.prototype.add = function () {
      const currentTime = Date.now();

      // 判断当前时间与上次记录的时间差，是否超过delay的限制
      if (currentTime - this.date > 1000 * this.delay) {
        this.count = 0; // 重置计数
      }

      this.count++; // 计数加一
      this.date = currentTime; // 更新时间记录

      // 返回当计数器达到maxCount时重置并返回true
      if (this.count >= this.maxCount) {
        this.count = 0; // 重置计数
        return true;
      }

      return false; // 否则返回false
    };
    e.prototype.clear = function () {
      this.count = 0;
      this.date = 0;
    };
    return e;
  }(e);
  t.ClickCnt = n;
  var r = function (t) {
    function e(e) {
      // 调用t函数，如果失败则使用this
      const o = t.call(this) || this;

      // 设置o的初始属性
      o._className = "UnlockForTime";
      o._localStorageKey = e || ""; // 设置本地存储键，默认为空字符串
      o._value = ""; // 初始化_value

      // 获取当前时间（假设此函数有意义）
      p.default().getNowTime();

      // 从本地存储中获取数据
      const storedValue = u.default.Servers.localStorageSrv.get(o._localStorageKey);
      o._value = storedValue ? JSON.parse(storedValue) : ""; // 解析存储值，若为null或空字符串则设为空字符串

      // 初始化o
      o._Initialize();

      // 返回o
      return o;
    }
    cc__extends(e, t);
    e.prototype.unlock = function () {
      // 获取当前时间
      const currentTime = p.default().getNowTime();

      // 格式化时间为"YYYY-MM-DD"格式
      this._value = `${currentTime.year}-${currentTime.month}-${currentTime.date}`;

      // 将formatted value存储到本地存储
      u.default.Servers.localStorageSrv.set(this._localStorageKey, JSON.stringify(this._value));
    };
    e.prototype.isUnlock = function () {
      var t = p.default().getNowTime();
      return this._value == t.year + "-" + t.month + "-" + t.date;
    };
    return e;
  }(e);
  t.UnlockForDay = r;
  var a = function (t) {
    function e(e) {
      // 调用t函数，如果失败则使用this
      const o = t.call(this) || this;

      // 设置o的初始属性
      o._className = "UnlockForever";
      o._localStorageKey = e || ""; // 设置本地存储键，默认为空字符串
      o._value = 0; // 初始化_value为0

      // 从本地存储中获取数据
      const storedValue = u.default.Servers.localStorageSrv.get(o._localStorageKey);
      o._value = storedValue ? JSON.parse(storedValue) : 0; // 解析存储值，若为null或空字符串则设为0

      // 初始化o
      o._Initialize();

      // 返回o
      return o;
    }
    cc__extends(e, t);
    e.prototype.unlock = function () {
      this._value = 1;
      u.default.Servers.localStorageSrv.set(this._localStorageKey, JSON.stringify(this._value));
    };
    e.prototype.isUnlock = function () {
      return 1 == this._value;
    };
    return e;
  }(e);
  t.UnlockForever = a;
  var s = function (t) {
    function e(e) {
      // 调用t函数，如果失败则使用this
      const o = t.call(this) || this;

      // 设置o的初始属性
      o._className = e || "ArrayBoostBase"; // 使用传入的e作为类名，默认值为"ArrayBoostBase"
      o._value = []; // 初始化_value为空数组

      // 初始化o
      o._Initialize();

      // 返回o
      return o;
    }
    cc__extends(e, t);
    Object.defineProperty(e.prototype, "data", {
      get() {
        return this._value;
      },
      enumerable: false,
      configurable: true
    });
    e.prototype.randomSort = function () {
      this._value.sort(function () {
        return Math.random() - .5;
      });
    };
    e.prototype.initFill = function (t, e) {
      this._value = new Array(t).fill(e);
    };
    e.prototype.clear = function () {
      this._value = [];
    };
    e.prototype.spilice = function (t) {
      // 查找数组中元素的索引
      const index = this._value.findIndex(t);

      // 如果找到了该元素
      if (index !== -1) {
        this._value.splice(index, 1); // 删除元素
        return true; // 返回成功
      } else {
        console.error(`${this._className}中未找到需要删除的元素`); // 记录错误
        return false; // 返回失败
      }
    };
    return e;
  }(e);
  t.ArrayBoostBase = s;
  var c = function (t) {
    function e(e, o, n) {
      // 调用t函数，如果失败则使用this
      const i = t.call(this) || this;

      // 设置对象的初始属性
      i._className = n || "二维数组增强基础"; // 使用传入的n作为类名，默认值为"二维数组增强基础"
      i._value = []; // 初始化_value为空数组
      i._size = { height: e || 0, width: o || 0 }; // 初始化_size并设置高度和宽度
      i._count = 0; // 初始化计数为0

      // 初始化对象
      i._Init(e, o);
      i._Initialize();

      // 返回对象
      return i;
    }
    cc__extends(e, t);
    Object.defineProperty(e.prototype, "size", {
      get() {
        return this._size;
      },
      enumerable: false,
      configurable: true
    });
    Object.defineProperty(e.prototype, "count", {
      get() {
        return this._count;
      },
      enumerable: false,
      configurable: true
    });
    e.prototype._Init = function (t, e) {
      this._count = t * e;

      // 初始化二维数组_value
      this._value = Array.from({ length: t }, () => Array(e).fill(null));

      // 更新_count为二维数组的总元素数量
      this._count = t * e;
    };
    Object.defineProperty(e.prototype, "data", {
      get() {
        return this._value;
      },
      enumerable: false,
      configurable: true
    });
    e.prototype.clear = function (t, e) {
      t && (this._size.height = t);
      e && (this._size.width = e);
      this._value = [];
      this._Init(this._size.height, this._size.width);
    };
    e.prototype.forEachAll = function (t) {
      const self = this; // 保存当前上下文

      // 遍历二维数组_value并调用函数t
      this._value.forEach((row, rowIndex) => {
        row.forEach((item, colIndex) => {
          t(item, colIndex, self._value[rowIndex], row, rowIndex, self._value);
        });
      });
    };
    return e;
  }(e);
  t.TwoDimensionalArrayBoostBase = c;
  var l = function (t) {
    function e(e, o) {
      // 调用t函数，如果失败则使用this
      const n = t.call(this) || this;

      // 设置对象的初始属性
      n._className = "NodePoolBoostBase";
      n._nodePool = new cc.NodePool(o); // 创建节点池
      n._prefab = e; // 设置预制体

      // 初始化对象
      n._Initialize();

      // 返回对象
      return n;
    }
    cc__extends(e, t);
    e.prototype.getPool = function () {
      return this._nodePool;
    };
    e.prototype.get = function () {
      // 如果节点池中有可用节点，则获取并返回一个节点
      if (this._nodePool.size() > 0) {
        return this._nodePool.get();
      }

      // 向节点池中填充新节点
      for (let i = 0; i < 5; i++) {
        this._nodePool.put(cc.instantiate(this._prefab));
      }

      // 从节点池中获取并返回一个节点
      return this._nodePool.get();
    };
    e.prototype.put = function (t) {
      this._nodePool.put(t);
    };
    e.prototype.clear = function () {
      this._nodePool.clear();
    };
    e.prototype.size = function () {
      return this._nodePool.size();
    };
    return e;
  }(e);
  t.NodePoolBoostBase = l;
  var d = function (t) {
    function e(e) {
      // 调用t函数，如果失败则使用this
      const o = t.call(this) || this;

      // 设置对象的初始属性
      o._className = "NodeDelegateBase";
      o._node = e || null; // 如果e存在，则赋值给_node，否则为null

      // 初始化对象
      o._Initialize();

      // 返回对象
      return o;
    }
    cc__extends(e, t);
    Object.defineProperty(e.prototype, "node", {
      get() {
        return this._node;
      },
      set(t) {
        this._node = t;
      },
      enumerable: false,
      configurable: true
    });
    e.prototype.remove = function () {
      this._node.destroy();
      this._node = null;
    };
    e.prototype.getHave = function () {
      return this._node && this._node.isValid;
    };
    return e;
  }(e);
  t.NodeDelegateBase = d;
  var h = function (t) {
    function e(e, o, n, i, r) {
      // 将o设置为0，如果它是undefined
      o = o !== undefined ? o : 0;

      // 调用t函数，如果失败则使用this
      const a = t.call(this) || this;

      // 设置对象的初始属性
      a._className = n || "缓存数字类"; // 使用传入的n作为类名，默认值为"缓存数字类"
      a._numberLocalStorageKey = e || ""; // 设置本地存储键，默认为空字符串
      a._initNumber = o; // 初始化数字
      a._value = 0; // 初始值为0
      a._min = i || NaN; // 最小值，默认为NaN
      a._max = r || NaN; // 最大值，默认为NaN

      // 初始化对象
      a._Initialize();

      // 返回对象
      return a;
    }
    cc__extends(e, t);
    e.prototype._Initialize = function () {
      // 从本地存储中获取值
      const storedValue = u.sers().localStorageSrv.get(this._numberLocalStorageKey);

      // 检查获取的值是否存在且不为空
      if (storedValue) {
        this._value = JSON.parse(storedValue); // 解析并赋值
      } else {
        this.set(this._initNumber); // 设置为初始值
      }

      // 调用父类的初始化方法
      t.prototype._Initialize.call(this);
    };
    e.prototype.set = function (t) {
      this._value = t;
      isNaN(this._min) || (this._value = this._value < this._min ? this._min : this._value);
      isNaN(this._max) || (this._value = this._value > this._max ? this._max : this._value);
      u.sers().localStorageSrv.set(this._numberLocalStorageKey, JSON.stringify(this._value));
    };
    e.prototype.get = function () {
      return this._value;
    };
    e.prototype.add = function (t) {
      undefined === t && (t = 1);
      this.set(this._value + t);
    };
    return e;
  }(e);
  t.LocalStorageNumber = h;
  t.PhysicsColliderCallBack = function () { };
  t.ColliderCallBack = function () { };
})(def_IClassNamespace || (def_IClassNamespace = {}));
exports.default = def_IClassNamespace;